// 小程序API服务封装（简化版）
import { config } from '@/config/api.js'
import authService from '@/utils/auth.js'

const BASE_URL = config.BASE_URL

// 构建查询字符串
const buildQueryString = (params) => {
  if (!params || typeof params !== 'object') return ''
  
  const queryParts = []
  for (const key in params) {
    if (params.hasOwnProperty(key) && params[key] !== null && params[key] !== undefined) {
      queryParts.push(encodeURIComponent(key) + '=' + encodeURIComponent(params[key]))
    }
  }
  return queryParts.join('&')
}

// 请求封装
const request = async (options) => {
  return new Promise(async (resolve, reject) => {
    try {
      // 获取有效token（如果需要认证）
      let token = null
      if (options.requireAuth !== false) {
        try {
          token = await authService.getValidToken()
        } catch (error) {
          console.error('获取token失败:', error)
          uni.showToast({
            title: '认证失败，请重新登录',
            icon: 'none'
          })
          reject(error)
          return
        }
      }

      // 显示加载提示
      if (options.loading !== false) {
        uni.showLoading({
          title: options.loadingText || '加载中...',
          mask: true
        })
      }

      // 构建完整URL
      const url = options.url.startsWith('http') ? options.url : BASE_URL + options.url
      
      // 构建请求参数
      const requestOptions = {
        url: url,
        method: options.method || 'GET',
        header: {
          'Content-Type': 'application/json',
          ...(token ? { 'Authorization': 'Bearer ' + token } : {}),
          ...options.header
        },
        success: (res) => {
          uni.hideLoading()
          
          if (res.statusCode === 200) {
            if (res.data.code === 200) {
              resolve(res.data)
            } else if (res.data.code === 401) {
              // token过期，清除本地存储并重新登录
              authService.logout()
              uni.showToast({
                title: '登录已过期，请重新登录',
                icon: 'none'
              })
              reject(res.data)
            } else {
              uni.showToast({
                title: res.data.msg || '请求失败',
                icon: 'none'
              })
              reject(res.data)
            }
          } else {
            uni.showToast({
              title: '网络请求失败',
              icon: 'none'
            })
            reject(res)
          }
        },
        fail: (err) => {
          uni.hideLoading()
          uni.showToast({
            title: '网络连接失败',
            icon: 'none'
          })
          reject(err)
        }
      }

      // 添加请求体
      if (options.data) {
        if (options.method === 'GET') {
          // GET请求将参数拼接到URL
          const params = buildQueryString(options.data)
          requestOptions.url += (requestOptions.url.includes('?') ? '&' : '?') + params
        } else {
          requestOptions.data = options.data
        }
      }

      uni.request(requestOptions)
    } catch (error) {
      uni.hideLoading()
      reject(error)
    }
  })
}

// 重点工作相关API
export const workApi = {
  // 获取重点工作列表
  getWorkList(params = {}) {
    return request({
      url: '/api/work/list',
      method: 'GET',
      requireAuth: false,
      data: {
        pageNum: params.pageNum || 1,
        pageSize: params.pageSize || 10,
        status: params.status || 'all',
        title: params.title || '',
        department: params.department || ''
      }
    })
  },

  // 获取重点工作详情
  getWorkDetail(id) {
    return request({
      url: `/api/work/detail/${id}`,
      method: 'GET'
    })
  },

  // 更新工作进度
  updateWorkProgress(id, data) {
    return request({
      url: `/api/work/progress/${id}`,
      method: 'PUT',
      data: data
    })
  }
}

// 快递登记相关API
export const expressApi = {
  // 获取我的快递列表
  getMyExpressList(params = {}) {
    return request({
      url: '/api/express/my/list',
      method: 'GET',
      data: {
        pageNum: params.pageNum || 1,
        pageSize: params.pageSize || 10,
        status: params.status || ''
      }
    })
  },

  // 提交快递登记
  submitExpress(data) {
    return request({
      url: '/api/express/submit',
      method: 'POST',
      data
    })
  }
}

// 党建学习相关API
export const partyStudyApi = {
  // 获取后台列表（需要权限）
  getStudyList(params = {}) {
    return request({
      url: '/api/party-study/list',
      method: 'GET',
      data: {
        pageNum: params.pageNum || 1,
        pageSize: params.pageSize || 10,
        status: params.status || '',
        title: params.title || ''
      }
    })
  },

  // 小程序公开列表
  getPublicStudyList() {
    return request({
      url: '/api/party-study/public/list',
      method: 'GET',
      requireAuth: false,
      loading: false
    })
  },

  // 获取详情
  getStudyDetail(id) {
    return request({
      url: `/api/party-study/${id}`,
      method: 'GET'
    })
  }
}

// 便民服务相关API
export const convenienceApi = {
  // 获取服务配置
  getServiceConfig() {
    return request({
      url: '/api/convenience/services',
      method: 'GET',
      requireAuth: false,
      loading: false
    })
  }
}

// 反馈相关API
export const feedbackApi = {
  // 获取反馈列表
  getFeedbackList(params = {}) {
    return request({
      url: '/api/feedback/list',
      method: 'GET',
      requireAuth: false,
      data: {
        pageNum: params.pageNum || 1,
        pageSize: params.pageSize || 10,
        status: params.status || 'all',
        phone: params.phone || '',
        name: params.name || '',
        type: params.type || ''
      }
    })
  },

  // 提交问题反馈
  submitFeedback(data) {
    return request({
      url: '/api/feedback/submit',
      method: 'POST',
      data: data,
      loadingText: '提交中...'
    })
  },

  // 获取反馈详情
  getFeedbackDetail(id) {
    return request({
      url: `/api/feedback/detail/${id}`,
      method: 'GET'
    })
  },

  // 处理反馈问题
  handleFeedback(id, data) {
    return request({
      url: `/api/feedback/handle/${id}`,
      method: 'PUT',
      data: data
    })
  }
}

// 文件上传相关API
export const uploadApi = {
  // 单张图片上传
  async uploadImage(filePath) {
    return new Promise(async (resolve, reject) => {
      try {
        // 获取有效token
        const token = await authService.getValidToken()
        
        uni.uploadFile({
          url: BASE_URL + '/common/upload',
          filePath: filePath,
          name: 'file',
          header: {
            'Authorization': 'Bearer ' + token
          },
          success: (res) => {
            try {
              const data = JSON.parse(res.data)
              if (data.code === 200) {
                resolve(data)
              } else if (data.code === 401) {
                // token过期，清除本地存储并重新登录
                authService.logout()
                uni.showToast({
                  title: '登录已过期，请重新登录',
                  icon: 'none'
                })
                reject(data)
              } else {
                uni.showToast({
                  title: data.msg || '上传失败',
                  icon: 'none'
                })
                reject(data)
              }
            } catch (e) {
              uni.showToast({
                title: '上传失败',
                icon: 'none'
              })
              reject(e)
            }
          },
          fail: (err) => {
            uni.showToast({
              title: '上传失败',
              icon: 'none'
            })
            reject(err)
          }
        })
      } catch (error) {
        console.error('获取token失败:', error)
        uni.showToast({
          title: '认证失败，请重新登录',
          icon: 'none'
        })
        reject(error)
      }
    })
  },

  // 删除图片
  deleteImage(fileName) {
    return request({
      url: '/common/upload/delete',
      method: 'DELETE',
      data: { fileName }
    })
  }
}

// 通用API
export const commonApi = {
  // 获取村级管理系统专用字典数据
  getVillageDict() {
    return request({
      url: '/api/dict/village',
      method: 'GET',
      requireAuth: false // 无需认证，公开接口
    })
  },

  // 获取问题类型列表（从字典数据中提取）
  async getProblemTypes() {
    try {
      const response = await this.getVillageDict()
      if (response.code === 200 && response.data && response.data.problem_type) {
        return {
          code: 200,
          msg: '获取成功',
          data: response.data.problem_type.map(item => item.dictLabel)
        }
      }
      // 如果获取失败，返回默认值
      return {
        code: 200,
        msg: '获取成功',
        data: ['基础设施', '环境卫生', '公共安全', '民生服务', '其他']
      }
    } catch (error) {
      console.error('获取问题类型失败:', error)
      // 返回默认值
      return {
        code: 200,
        msg: '获取成功',
        data: ['基础设施', '环境卫生', '公共安全', '民生服务', '其他']
      }
    }
  },

  // 获取村小组列表
  async getVillageGroups() {
    try {
      const response = await this.getVillageDict()
      if (response.code === 200 && response.data && response.data.village_group) {
        return response.data.village_group.map(item => item.dictLabel || item.dictValue || '')
      }
    } catch (error) {
      console.warn('获取村小组失败:', error)
    }
    return ['刘家湾组', '陈家湾组', '杜家冲组', '五坝组', '长房组', '大坪子组']
  },

  // 获取工作状态列表（从字典数据中提取）
  async getWorkStatus() {
    try {
      const response = await this.getVillageDict()
      if (response.code === 200 && response.data && response.data.work_status) {
        return {
          code: 200,
          msg: '获取成功',
          data: response.data.work_status
        }
      }
      return { code: 500, msg: '获取失败', data: null }
    } catch (error) {
      console.error('获取工作状态失败:', error)
      return { code: 500, msg: '获取失败', data: null }
    }
  },

  // 获取反馈状态列表（从字典数据中提取）
  async getFeedbackStatus() {
    try {
      const response = await this.getVillageDict()
      if (response.code === 200 && response.data && response.data.feedback_status) {
        return {
          code: 200,
          msg: '获取成功',
          data: response.data.feedback_status
        }
      }
      return { code: 500, msg: '获取失败', data: null }
    } catch (error) {
      console.error('获取反馈状态失败:', error)
      return { code: 500, msg: '获取失败', data: null }
    }
  },

  // 获取状态枚举（兼容旧接口）
  getStatusEnums() {
    return this.getVillageDict()
  }
}

// 工具函数
export const utils = {
  // 处理图片URL，添加完整路径
  getImageUrl(url) {
    if (!url) return ''
    if (url.startsWith('http')) return url
    return BASE_URL + url
  },

  // 处理图片URLs字符串，转换为数组
  parseImageUrls(urls) {
    if (!urls) return []
    if (Array.isArray(urls)) return urls
    return urls.split(',').filter(url => url.trim())
  },

  // 将图片数组转换为URLs字符串
  stringifyImageUrls(images) {
    if (!images || !Array.isArray(images)) return ''
    return images.filter(url => url.trim()).join(',')
  },

  // 手机号脱敏
  maskPhone(phone) {
    if (!phone) return ''
    return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
  }
}
